LLM 进阶——微调与部署

# 1. 现有数据整理
# - 企业文档
# - 客服对话记录
# - 代码仓库
# - 产品手册

# 2. 人工生成
# - 专家编写问答对
# - 标注数据集
# - 修正模型输出

# 3. 数据增强
# - 同义改写
# - 举例扩展
# - 反例生成

# 4. 数据清洗
# 去重
def deduplicate(data):
    seen = set()
    unique = []
    for item in data:
        hash = hash(item['text'])
        if hash not in seen:
            seen.add(hash)
            unique.append(item)
    return unique

# 去除隐私信息
def remove_pii(text):
    import re
    # 电话
    text = re.sub(r'\d{3}-\d{4}-\d{4}', '[PHONE]', text)
    # 邮箱
    text = re.sub(r'\S+@\S+', '[EMAIL]', text)
    return text

# 质量过滤
def filter_quality(data):
    # 过滤太短的样本
    # 过滤重复信息
    # 过滤无意义内容
    return [item for item in data if len(item['text']) > 50]

from sklearn.model_selection import train_test_split

# 划分训练集和验证集
train_data, val_data = train_test_split(
    all_data,
    test_size=0.1,      # 10% 作为验证集
    random_state=42
)

# 保存数据集
import json

def save_jsonl(data, path):
    with open(path, 'w', encoding='utf-8') as f:
        for item in data:
            f.write(json.dumps(item, ensure_ascii=False) + '\n')

save_jsonl(train_data, 'train.jsonl')
save_jsonl(val_data, 'validation.jsonl')

import torch
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    TrainingArguments,
    Trainer
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from datasets import load_dataset

# 1. 加载模型和分词器
model_name = "Qwen/Qwen2.5-7B-Instruct"

tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

# 2. 使用 QLoRA 加载量化模型
from transformers import BitsAndBytesConfig

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True,
)

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",
)

# 3. 准备 LoRA 配置
lora_config = LoraConfig(
    r=16,                     # rank
    lora_alpha=32,            # alpha
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

# 4. 加载数据集
dataset = load_dataset('json', data_files={
    'train': 'train.jsonl',
    'validation': 'validation.jsonl'
})

# 5. 数据预处理
def preprocess_function(examples):
    inputs = [f"Instruction: {i}\nResponse: {o}"
              for i, o in zip(examples['instruction'], examples['output'])]

    model_inputs = tokenizer(
        inputs,
        max_length=512,
        truncation=True,
        padding="max_length"
    )

    labels = tokenizer(
        examples['output'],
        max_length=512,
        truncation=True,
        padding="max_length"
    )

    model_inputs["labels"] = labels["input_ids"]
    return model_inputs

tokenized_dataset = dataset.map(preprocess_function, batched=True)

# 6. 训练配置
training_args = TrainingArguments(
    output_dir="./qwen-lora",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    per_device_eval_batch_size=4,
    gradient_accumulation_steps=4,
    warmup_steps=100,
    learning_rate=2e-4,
    fp16=True,
    logging_steps=10,
    save_steps=100,
    eval_steps=100,
    save_total_limit=2,
)

# 7. 创建 Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset["train"],
    eval_dataset=tokenized_dataset["validation"],
)

# 8. 开始训练
trainer.train()

# 9. 保存模型
model.save_pretrained("./my-finetuned-model")
tokenizer.save_pretrained("./my-finetuned-model")

# Python 客户端
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="empty"
)

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "你好"}]
)

print(response.choices[0].message.content)

# 1. 使用 Flash Attention
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    use_flash_attention_2=True,  # 加速 2-3x
    device_map="auto"
)

# 2. 使用 KV Cache
outputs = model.generate(
    inputs,
    use_cache=True,  # 启用 KV cache
    past_key_values=past_kv  # 复用缓存
)

# 3. 批处理
# 一次处理多个请求，提高吞吐量

# 4. 量化
# 使用 INT4/INT8 量化模型

# 5. Continuous Batching
# 使用 vLLM 或 TGI 的连续批处理功能

# 监控显存使用
import torch

print(f"GPU Memory: {torch.cuda.memory_allocated() / 1024**3:.2f} GB")
print(f"GPU Memory Reserved: {torch.cuda.memory_reserved() / 1024**3:.2f} GB")

# 监控推理速度
import time

start = time.time()
outputs = model.generate(inputs, max_new_tokens=100)
elapsed = time.time() - start
tokens_per_second = 100 / elapsed
print(f"Speed: {tokens_per_second:.2f} tokens/sec")

# 使用 TensorBoard 监控训练
from torch.utils.tensorboard import SummaryWriter

writer = SummaryWriter()
writer.add_scalar('Loss/train', loss, step)
writer.add_scalar('LR', learning_rate, step)